package com.atguigu.day17.treeset;

import org.junit.Test;

import java.util.Comparator;
import java.util.TreeSet;

/*
Collection: 集合的顶级接口
    -- List 有序 不唯一
       -- ArrayList
       -- LinkedList
    -- Set 对比Collection没有新增方法
          唯一(数据不能重复)

Collection集合的遍历:
      1.迭代器遍历
      2.增强for遍历(底层是迭代器)
           for(集合元素类型 变量名:集合名){
               变量名:集合内的一个个元素
           }
    注意:
      1. 为什么集合对象可以使用迭代器遍历(增强for)
            因为集合对象是  Iterable接口的孩子
      2. 遍历时通过集合对象增删元素 [可能]发生 并发修改异常
          modCount: 记录对集合修改的次数 增加/删除 都会导致 modCount++
      3.使用迭代器对象删除元素 不会发生并发修改异常

List: 特点 有序
          不唯一
      遍历:  4种
      实现类:
           数组  ArrayList vs  Vector:
                同: 1.底层都是数组 Object[]
                    2.有共同的父亲 AbstractList
                不同:
                   1.创建对象时底层数组长度不同
                      ArrayList 底层数组长度为0 第一次添加数据时 长度为10
                      Vector 底层数组长度为10
                   2.扩容规则不同:
                       ArrayList: 原来的1.5倍
                       Vector:  capacityIncrement=0    原来的2倍
                                capacityIncrement>0    旧的长度+capacityIncrement
                   3.线程安全问题
                         ArrayList: 线程不安全 效率高
                         Vector:   线程安全  效率低
           双向链表: LinkedList:
                      新增了操作头尾的方法
                      模拟栈和队列操作:
                             栈: FILO first in last out
                                 刷盘子 压子弹
                             队列: FIFO first in first out
                                 超市结账
Set: 唯一(数据不重复)
   HashSet:
          底层数据结构: 哈希表
          特点:
               无序:(非添加顺序)
               唯一:
          注意:
              0.哈希表存储数据的流程
                 1.计算对象的哈希码 获取添加的位置
                   重写hashCode() 两个对象的属性值相同 返回相同的哈希码
                 2.如果指定位置有值 调用equals() 判断内容是否一样 一样不添加
                   重写equals() 比较两个对象的属性值
              1.如果是自定义类型数据  必须重写 hashCode() equals()
   LinkedHashSet:
          底层数据结构: 哈希表 + 链表
                 特点:
                     有序:添加顺序
                     唯一:
                 注意:
                     1.如果是自定义类型数据  必须重写 hashCode() equals()
  TreeSet:
        底层数据结构: 红黑树
              特点:
                  有序:排序顺序
                  唯一:
              注意:
                 1.如果是自定义类型数据 需要指定比较规则
                                                Comparable Comparator
                 2.比较规则返回0 认定数据重复

 */
public class TreeSetTest {
    @Test
    public void test03() {
        Cat c1 = new Cat("小花猫", 2, 3.5);
        Cat c2 = new Cat("狸猫", 1, 3.2);
        Cat c3 = new Cat("虹猫", 5, 3.3);
        Cat c4 = new Cat("蓝猫", 4, 3.4);
        Cat c5 = new Cat("黑猫", 6, 3.4);

        Comparator<Cat> c = new Comparator<Cat>() {
            @Override
            public int compare(Cat o1, Cat o2) {
                return Double.compare(o1.weight,o2.weight);
            }
        };
        TreeSet<Cat> set = new TreeSet<>(c);
        set.add(c1);
        set.add(c2);
        set.add(c3);
        set.add(c4);
        set.add(c5);

        System.out.println("set.size() = " + set.size());
        for (Cat cat : set) {
            System.out.println("cat = " + cat);
        }


    }

    @Test
    public void test02() {
        TreeSet<String> set = new TreeSet<>();
        set.add("A");
        set.add("D");
        set.add("C");
        set.add("B");
        set.add("B");
        System.out.println("set.size() = " + set.size());
        for (String s : set) {
            System.out.println("s = " + s);
        }
    }

    @Test
    public void test01() {
        TreeSet<Integer> set = new TreeSet<>();
        set.add(99);
        set.add(33);
        set.add(66);
        set.add(77);
        set.add(55);
        set.add(55);

        System.out.println("set.size() = " + set.size());

        for (Integer i : set) {
            System.out.println("i = " + i);
        }

    }
}
